classes/archiver/class.zipprovider.inc.php

Go to the documentation of this file.

<?php
/*--------------------------------------------------------------------------+
This file is part of eStudy.
ressourcen/classes/archiver/class.zipprovider.inc.php
- Module group: File Manager
- Description:  Class "ZipProvider"
- Version:      $Id: class.zipprovider.inc.php 2348 2009-06-04 13:29:47Z commana $
- Author(s):    Bjoern Kasteleiner <bjoern.kasteleiner@mni.fh-giessen.de>
+---------------------------------------------------------------------------+
This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or any later version.
+---------------------------------------------------------------------------+
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+--------------------------------------------------------------------------*/

if ( !defined("PATH_TO_ROOT") ) {
        define( "PATH_TO_ROOT", "../../../" );
}

require_once (PATH_TO_ROOT."ressourcen/classes/filemanager/class.file.inc.php");
require_once (PATH_TO_ROOT."ressourcen/classes/filemanager/class.folder.inc.php");
require_once (PATH_TO_ROOT."ressourcen/classes/archiver/class.zipvisitor.inc.php");
require_once (PATH_TO_ROOT."ressourcen/classes/archiver/interface.archiveprovider.inc.php");
require_once (PATH_TO_ROOT."ressourcen/classes/archiver/class.archiverexception.inc.php");


class ZipProvider implements ArchiveProvider {
        private $folder;
        private $recursion;
        private $tempFile;
                
        public function __construct(Folder $folder, $recursion = FALSE, $tempFile = null) {
                assert(!is_null($folder));
                assert($folder instanceof Folder);
                
                global $settings;
                
                $this->folder = $folder;
                $this->recursion = $recursion;
                
                if (empty($tempFile)) {
                        $basedir  = PATH_TO_ROOT.$settings["upload_path"];
                        $basedir .= 'filemanager/courseID/'.$_SESSION['course'];
                        
                        $tempFile = tempnam($basedir, "archiver");
                } 
                
                $this->tempFile = $tempFile;
        }
        
        public function __destruct() {
                if (file_exists($this->tempFile)) {
                        unlink($this->tempFile); 
                }
        }
        
        public function setRecursion($recursion) {
                $this->recursion = $recursion;
        }
        
        public function getRecursion() {
                return $this->recursion;
        }
        
        public function setTempFile($tempFile) {
                $this->tempFile = $tempFile;
        }
        
        public function getTempFile() {
                return $this->tempFile;
        }
        
        public function setFolder(Folder $folder) {
                $this->folder = $folder;
        }
        
        public function getFolder() {
                return $this->folder;
        }
        
        public function createArchive() {
                $zipArchiver = new ZipArchive();
                if ($zipArchiver->open($this->tempFile, ZipArchive::OVERWRITE) !== TRUE) {
                        throw new ArchiverException("Fehler beim Anlegen des Archivs. ".$this->tempFile);
                }
                
                $zipVisitor = new ZipVisitor($zipArchiver, $this->recursion);
                $this->folder->archiverAccept($zipVisitor); 
                
                if ($zipArchiver->status != ZipArchive::ER_OK) {
                        throw new ArchiverException("Fehler beim Erzeugen des Archivs: ".$zipArchiver->status);
                }
                $zipArchiver->close();
        }
        
        public function sendArchive() {
                global $resDB;
                
        if (file_exists($this->tempFile)) {
                $filename  = $resDB->getCourseShortNameByID($this->folder->getCourseID());
                $filename .= "-".$this->folder->getLink().".zip";
                
                $this->logFolderDownload($this->folder);
                
                header("Content-Type: application/zip");
                header("Content-Disposition: attachment; filename=\"".$filename."\"");
                header("Content-Transfer-Encoding: binary");
                header("Content-Length: ".filesize($this->tempFile));
                
                readfile($this->tempFile);
                unlink($this->tempFile);
        } else {
                throw new ArchiverException("Bereitgestelltes Zip Archive konnte nicht gefunden werden.");
        }
        }
        
        private function logFolderDownload(Folder $folder) {
                global $resDB;
                
                $resDB->logResourceDownload($folder->getID());
                
                $files = $folder->getFiles();
                foreach ($files as $file) {
                        $resDB->logResourceDownload($file->getID());
                }
                
                if ($this->recursion) {
                        $subFolders = $folder->getSubFolders();
                        foreach ($subFolders as $subFolder) {
                                $this->logFolderDownload($subFolder);
                        }
                }
        }
        
        
        public static function checkArchiveSize(Folder $folder, $recursion) {
                global $resDB;

                $size = 0;
                
                $files = $folder->getFiles();
                foreach ($files as $file) {
                        $size += $file->getSize();
                }
                
                if ($recursion) {
                        $subFolders = $folder->getSubFolders();
                        foreach ($subFolders as $subFolder) {
                                $size += self::checkArchiveSize($subFolder, $recursion);
                        }       
                }
                
                return $size;
        }
}

?>

---